// 引入SDK核心类
const QQMapWX = require('../../utils/qqmap-wx-jssdk.js');
const config = require('../../config.js');

// 实例化API核心类
const qqmapsdk = new QQMapWX({
  key: config.mapKey
});

Page({
  data: {
    meetingInfo: {},
    downloadProgress: 36,
    reasonLength: 0,
    reason: '',
    mid: '',
    distance: 0,  // 添加距离字段
    downloadFiles: null,
    signStatus: '' // 添加签到状态：'未开始'|'进行中'|'已结束'|'已签到'
  },

  onLoad(options) {
    // 根据id获取会议详情
    if (options.mid) {
      this.setData({
        mid: options.mid
      })
      this.getMeetingDetail(options.mid)
    }
  },

  // 检查签到时间状态
  checkSignStatus() {
    const now = new Date().getTime();
    const startTime = new Date(this.data.meetingInfo.startTime).getTime();
    const endTime = new Date(this.data.meetingInfo.endTime).getTime();
    
    let status = '';
    if (this.data.meetingInfo.status === '已签到') {
      status = '已签到';
    } else if (now < startTime) {
      status = '未开始';
    } else if (now > endTime) {
      status = '已结束';
    } else {
      status = '进行中';
    }
    
    this.setData({
      signStatus: status
    });
  },

  getMeetingDetail(id) {
    const app = getApp()
    app.meetingApi.meetingDetail(id).then(res => {
      this.setData({
        meetingInfo: res.data.data,
        reasonLength: res.data.data.reason ? res.data.data.reason.length : 0
      })
      this.checkSignStatus(); // 获取会议详情后检查签到状态
      console.log(res.data)
    })
  },

 // 下载所有文件
 downloadAllFiles: function (e) {
  const files = e.currentTarget.dataset.files || [];
  const content = e.currentTarget.dataset.content || '';

  wx.showLoading({
    title: '准备下载...'
  });
  console.log('附件数量:', files.length);
  // 准备下载队列
  let downloadQueue = [];
      // 添加附件到下载队列
      if (files && files.length > 0) {
        downloadQueue = downloadQueue.concat(files.map(file => ({
          isContent: false,
          url: file.url,
          name: file.name,
        })));
      }
      // 开始下载
      this.processDownloadQueue(downloadQueue, []);
    },
// 处理下载队列
processDownloadQueue: function (queue, savedFiles) {
  if (queue.length === 0) {
    // 所有文件处理完成
    wx.hideLoading();
    if (savedFiles.length > 0) {
      // 保存到缓存
      wx.setStorageSync(`downloaded_meeting_files_${this.data.meetingInfo.mid}`, savedFiles);

      // 更新按钮状态，但不自动跳转
      this.setData({
        downloadedFiles: savedFiles
      });

      wx.showToast({
        title: '下载完成',
        icon: 'success'
      });
    }
    return;
  }

  const currentFile = queue[0];
  const remainingQueue = queue.slice(1);

  if (currentFile.isContent) {
    // 保存文本内容
    try {
      const filePath = `${wx.env.USER_DATA_PATH}/${currentFile.name}`;
      wx.getFileSystemManager().writeFileSync(
        filePath,
        currentFile.content,
        'utf8'
      );

      // 使用文件路径而不是内容进行上传
      const app = getApp();
      app.userRequest.uploadFiles(filePath, {
        "filename": currentFile.name
      }).then(
        res => {
          savedFiles.push({
            path: filePath,
            name: currentFile.name,
            type: 'docx',
            url: res.data.data
          });
          this.processDownloadQueue(remainingQueue, savedFiles);
        }
      ).catch(err => {
        console.error('上传文件失败', err);
        // 即使上传失败，也将文件添加到列表中，只是没有URL
        savedFiles.push({
          path: filePath,
          name: currentFile.name,
          type: 'txt',
          url: null
        });
        this.processDownloadQueue(remainingQueue, savedFiles);
      });
    } catch (err) {
      console.error('保存内容失败', err);
      this.processDownloadQueue(remainingQueue, savedFiles);
    }
  } else if (currentFile.isWordDoc) {
    // 处理Word文档，这种情况下已经有本地文件路径，需要上传到后端获取URL
    try {
      // 使用文件路径上传到后端
      const app = getApp();
      app.userRequest.uploadFiles(currentFile.path, {
        "filename": currentFile.name
      }).then(
        res => {
          savedFiles.push({
            path: currentFile.path,
            name: currentFile.name,
            type: currentFile.type,
            size: currentFile.size || 0,
            url: res.data.data // 保存后端返回的URL
          });
          console.log('Word文档上传成功，URL:', res.data.data);
          this.processDownloadQueue(remainingQueue, savedFiles);
        }
      ).catch(err => {
        console.error('上传Word文档失败', err);
        // 即使上传失败，也将文件添加到列表中，只是没有URL
        savedFiles.push({
          path: currentFile.path,
          name: currentFile.name,
          type: currentFile.type,
          size: currentFile.size || 0,
          url: null
        });
        this.processDownloadQueue(remainingQueue, savedFiles);
      });
    } catch (err) {
      console.error('处理Word文档失败', err);
      // 出错时也添加到列表，但没有URL
      savedFiles.push({
        path: currentFile.path,
        name: currentFile.name,
        type: currentFile.type,
        size: currentFile.size || 0
      });
      this.processDownloadQueue(remainingQueue, savedFiles);
    }
  } else {
    // 下载附件
    if (!currentFile.url) {
      console.error('文件URL为空:', currentFile);
      this.processDownloadQueue(remainingQueue, savedFiles);
      return;
    }

    wx.downloadFile({
      url: currentFile.url,
      success: (res) => {
        if (res.statusCode === 200) {
          // 获取文件扩展名
          const ext = currentFile.url.substring(currentFile.url.lastIndexOf('.') + 1).toLowerCase();

          // 保存到本地存储
          try {
            const filePath = `${wx.env.USER_DATA_PATH}/${currentFile.name}.${ext}`;
            wx.getFileSystemManager().saveFileSync(res.tempFilePath, filePath);

            savedFiles.push({
              path: filePath,
              name: currentFile.name,
              type: ext,
              size: currentFile.size,
              url: currentFile.url // 保存原始URL
            });
          } catch (err) {
            console.error('保存文件失败', err);
            // 如果保存失败，使用临时路径
            savedFiles.push({
              path: res.tempFilePath,
              name: currentFile.name,
              type: ext,
              size: currentFile.size,
              url: currentFile.url // 保存原始URL
            });
          }
        }
        this.processDownloadQueue(remainingQueue, savedFiles);
      },
      fail: (err) => {
        console.error('下载文件失败', err);
        this.processDownloadQueue(remainingQueue, savedFiles);
      }
    });
  }
},

  // 跳转到文件列表页面
  goToFileList: function () {
    wx.navigateTo({
      url: `/pages/files/fileList?pid=downloaded_meeting_files_${this.data.meetingInfo.mid}`
    });
  },

  signIn() {
    // 先检查签到状态
    if (this.data.signStatus === '未开始') {
      wx.showToast({
        title: '签到还未开始',
        icon: 'none'
      });
      return;
    }
    
    if (this.data.signStatus === '已结束') {
      wx.showToast({
        title: '签到已结束，你未签到',
        icon: 'none'
      });
      return;
    }

    console.log('开始签到流程')
    
    // 先检查是否已授权
    wx.authorize({
      scope: 'scope.userLocation',
      success: () => {
        // 已授权，继续获取位置
        this.getLocationAndSign()
      },
      fail: () => {
        // 未授权，显示授权弹窗
        wx.showModal({
          title: '需要位置权限',
          content: '签到功能需要获取您的位置信息，请授权',
          success: (res) => {
            if (res.confirm) {
              wx.openSetting({
                success: (settingRes) => {
                  if (settingRes.authSetting['scope.userLocation']) {
                    this.getLocationAndSign()
                  }
                }
              })
            }
          }
        })
      }
    })
  },

  // 将原来的定位和签到逻辑抽取为单独的方法
  getLocationAndSign() {
    wx.showLoading({
      title: '获取位置中...'
    })
    
    console.log('当前会议信息:', {
      地点: this.data.meetingInfo.location1,
      详细地址: this.data.meetingInfo.location2
    })
    
    wx.getLocation({
      type: 'gcj02',
      success: (res) => {
        wx.hideLoading()
        const userLatitude = res.latitude
        const userLongitude = res.longitude
        
        console.log('用户当前位置:', {
          latitude: userLatitude,
          longitude: userLongitude
        })

        // 获取用户当前位置的地址信息
        qqmapsdk.reverseGeocoder({
          location: {
            latitude: userLatitude,
            longitude: userLongitude
          },
          success: (addressRes) => {
            console.log('用户当前位置地址:', addressRes.result.address)
          }
        })
        
        this.getMeetingLocation().then(meetingLocation => {
          console.log('会议地点解析结果:', meetingLocation)

          const distance = this.calculateDistance(
            userLatitude,
            userLongitude, 
            meetingLocation.latitude,
            meetingLocation.longitude
          )
          
          console.log('距离计算结果:', {
            距离: Math.round(distance) + '米',
            是否在范围内: distance <= 500 ? '是' : '否'
          })
          
          this.setData({
            distance: Math.round(distance)
          })
          
          if(distance <= 800) {
            console.log('在签到范围内')
            wx.showLoading({
              title: '签到中...'
            })
            const app = getApp()
            app.meetingApi.toSign(this.data.mid).then(res => {   
              if (res.data.code === 200) {
                this.setData({
                  "meetingInfo.status": '已签到'
                })
                wx.showToast({
                  title: '签到成功',
                  icon: 'success'
                })
              }
            })
          } else {
            console.log('不在签到范围内，超出500米')
            wx.showToast({
              title: `不在签到范围内，距离${Math.round(distance)}米`,
              icon: 'none'
            })
          }
        }).catch(err => {
          console.error('地址解析失败:', err)
          wx.showToast({
            title: '地址解析失败',
            icon: 'none'
          })
        })
      },
      fail: (err) => {
        wx.hideLoading()
        console.error('获取位置失败:', err)
        wx.showModal({
          title: '获取位置失败',
          content: '请确保已开启定位权限，并且在可以定位的环境下使用',
          showCancel: false
        })
      }
    })
  },

  // 通过地址解析获取经纬度
  getMeetingLocation() {
    return new Promise((resolve, reject) => {
      const address = this.data.meetingInfo.location2
      
      // 先检查缓存
      const cache = wx.getStorageSync('meeting_address_cache') || {};
      if (cache[address]) {
        console.log('使用缓存的地址坐标');
        return resolve(cache[address]);
      }

      console.log('开始解析会议地址:', address)
      
      // 没有缓存才调用API
      qqmapsdk.geocoder({
        address: address,
        success: (res) => {
          console.log('地址解析结果:', res)
          if (res.status === 0) {
            const location = res.result.location
            console.log('会议地点坐标:', location)
            const result = {
              latitude: location.lat,
              longitude: location.lng
            };
            
            // 存入缓存
            cache[address] = result;
            wx.setStorageSync('meeting_address_cache', cache);
            
            resolve(result)
          } else {
            reject(new Error('地址解析失败'))
          }
        },
        fail: reject
      })
    })
  },

  // 计算两点之间的距离(米)
  calculateDistance(lat1, lng1, lat2, lng2) {
    const R = 6371000 // 地球半径(米)
    const dLat = this.toRad(lat2 - lat1)
    const dLng = this.toRad(lng2 - lng1)
    const a = Math.sin(dLat/2) * Math.sin(dLat/2) +
      Math.cos(this.toRad(lat1)) * Math.cos(this.toRad(lat2)) * 
      Math.sin(dLng/2) * Math.sin(dLng/2)
    const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a))
    return R * c
  },

  // 角度转弧度
  toRad(d) {
    return d * Math.PI / 180
  },

  inputReason(e) {
    this.setData({
      reason: e.detail.value,
      reasonLength: e.detail.value.length
    })
  },

  submitReason() {
    if (!this.data.reason.trim()) {
      wx.showToast({
        title: '请输入原因',
        icon: 'none'
      })
      return
    }

    // TODO: 提交无法签到原因
    wx.showLoading({
      title: '提交中...',
    })

    const app = getApp()
    const reason = this.data.reason
    const mid = this.data.mid
    app.meetingApi.submitReason({
      reason,
      mid
    }).then(
      res => {
        if (res.data.code === 200) {
          this.setData({
            meetingInfo: res.data.data
          })
          wx.hideLoading()
          wx.showToast({
            title: '提交成功',
            
          })
        } else {
          wx.showToast({
            title: '提交失败',
            icon: 'none'
          })
        }
      })
  },
  onPullDownRefresh() {
    const id = this.data.mid
    this.getMeetingDetail(id)
    setTimeout(() => {
      wx.stopPullDownRefresh()
      wx.showToast({
        title: '刷新成功',
        icon: 'success',
        duration: 1000
      })
    }, 1000)
  },
})